/**
 * Created by baidm in 2021/2/6 on 19:51
 */
/**
 * 常用几何方法
 */
class GeometricUtil {
  constructor() {

  }

  /**
   * 已知直角三角形一直角边的倾斜弧度，求另一条直角边的倾斜弧度
   * @param rad
   * @returns {*}
   */
  getRadPositive(rad) {
    return rad + Math.PI * 2
  }

  /**
   * 两点相减
   * @param p1
   * @param p2
   * @returns {{x: number, y: number}}
   */
  getPointBaseOrigin(p1, p2) {
    const dx = p2.x - p1.x;
    const dy = p2.y - p1.y;
    return {
      x: dx, y: dy
    }
  }

  /**
   * 根据两点获取距离
   * @param p1
   * @param p2
   * @returns {number}
   */
  getDistance(p1, p2) {
    const p = this.getPointBaseOrigin(p1, p2);
    return Math.sqrt(p.x * p.x + p.y * p.y)
  }

  /**
   * 根据两点获取一点到另一点的方向
   * @param p1
   * @param p2
   * @returns {number}
   */
  getRadian(p1, p2) {
    const p = this.getPointBaseOrigin(p1, p2);
    return Math.atan2(p.y, p.x)
  }

  /**
   * 已知射线起点point和方向rad，求其发射到某段距离len时的点位
   * @param rad
   * @param len
   * @param point
   * @returns {{x: *, y: *}}
   */
  getPointByVector(rad, len, point) {
    return {
      x: Math.cos(rad) * len + point.x,
      y: Math.sin(rad) * len + point.y
    }
  }

  /**
   * 取两点间的中点
   * @param p1
   * @param p2
   * @returns {{x: number, y: number}}
   */
  getCenterPoint(p1, p2) {
    return {
      x: (p1.x + p2.x) / 2,
      y: (p1.y + p2.y) / 2
    }
  }

  /**
   * 根据勾股定理中的锐角和对边长度，获取斜边长度
   * @param rad
   * @param a
   * @returns {number}
   */
  getCbyRadA(rad, a) {
    return a / Math.sin(rad)
  }

  /**
   * 根据勾股定理中的锐角和斜边长度，获取临边长度
   * @param rad
   * @param c
   * @returns {number}
   */
  getBbyRadC(rad, c) {
    return Math.cos(rad) * c
  }

  /**
   * 根据勾股定理中的锐角和斜边长度，获取对边长度
   * @param rad
   * @param c
   * @returns {number}
   */
  getAbyRadC(rad, c) {
    return Math.sin(rad) * c
  }

  /**
   * 根据圆弧的起点、端点、弧度，获取圆心位置
   * @param startPoint
   * @param endPoint
   * @param rad
   * @returns {{x: *, y: *}}
   */
  getObyStarEndRad(startPoint, endPoint, rad) {
    const centerPoint = this.getCenterPoint(startPoint, endPoint);
    const aLen = this.getDistance(startPoint, endPoint) / 2;
    const aRad = this.getRadian(startPoint, endPoint);
    const bRad = this.getRadPositive(aRad);
    const radius = this.getCbyRadA(rad / 2, aLen);
    const bLen = this.getBbyRadC(rad / 2, radius);
    return this.getPointByVector(bRad, bLen, centerPoint);
  }

  /**
   * 根据圆弧的起点、端点、弧度，获取半径
   * @param startPoint
   * @param endPoint
   * @param rad
   * @returns {number}
   */
  getRadiusbyStarEndRad(startPoint, endPoint, rad) {
    const aLen = this.getDistance(startPoint, endPoint) / 2;
    return this.getCbyRadA(rad / 2, aLen);
  }
}

export default new GeometricUtil()